// 配置接口地址
const BASE_URL = process.env.NODE_ENV === 'development'
  ? 'https://www.xinxingbaihuo.cn'  // 开发环境
  // : 'http://8.138.206.71:3000' // 生产环境
  // ? 'http://8.138.206.71'  // 开发环境
  : 'https://www.xinxingbaihuo.cn' // 生产环境

const TIMEOUT = 60000 // 请求超时时间
// 请求队列
let requestQueue = []
let isRefreshing = false

// 登录方法
const login = async () => {
  try {
    // 获取微信登录凭证
    const { code } = await uni.login({
      provider: 'weixin'
    })
    
    // 调用登录接口
    const res = await uni.request({
      url: `${BASE_URL}/user/login`,
      method: 'POST',
      data: { code }
    })
    
    // 检查响应状态和数据
    if (res.statusCode === 200 && res.data) {
      // 保存token和用户信息
      const { token, userInfo } = res.data.data
      console.log(token, userInfo )
      if (token) {
        uni.setStorageSync('token', token)
        uni.setStorageSync('userInfo', userInfo || {})
        return token
      }
    }
    
    throw new Error('登录失败: 无效的响应数据')
    
  } catch (err) {
    console.error('登录失败:', err)
    uni.showToast({
      title: '登录失败',
      icon: 'none'
    })
    return Promise.reject(err)
  }
}

// 请求拦截器
const requestInterceptor = (config) => {
  // 获取token
  const token = uni.getStorageSync('token')
  
  if (token) {
    config.header = {
      ...config.header,
      'Authorization': `Bearer ${token}`
    }
  }
  
  return config
}

// 响应拦截器
const responseInterceptor = async (response, config) => {
  const { statusCode, data } = response
  console.log(response)
  if (statusCode === 200) {
    return data.data
  }
  
  // token过期或未登录
  if (statusCode === 401) {
    if (!isRefreshing) {
      isRefreshing = true
      try {
        // 调用登录接口获取新token
        await login()
        
        // 重新发起之前被拦截的请求
        const res = await request({
          ...config,
          header: {
            ...config.header,
            'Authorization': `Bearer ${uni.getStorageSync('token')}`
          }
        })
        
        return res
        
      } catch (err) {
        // 登录失败处理
        uni.removeStorageSync('token')
        uni.navigateTo({
          url: '/pages/login/index'
        })
        return Promise.reject(err)
      } finally {
        isRefreshing = false
      }
    } else {
      // 将请求加入队列
      return new Promise(resolve => {
        requestQueue.push(async () => {
          try {
            const res = await request({
              ...config,
              header: {
                ...config.header,
                'Authorization': `Bearer ${uni.getStorageSync('token')}`
              }
            })
            resolve(res)
          } catch (err) {
            resolve(Promise.reject(err))
          }
        })
      })
    }
  }
  
  // 统一错误处理
  showError(response)
  return Promise.reject(response)
}


// 错误提示
const showError = (error) => {
  let message = '请求失败'
  if (error.data?.message) {
    message = error.data.message
  }
  uni.showToast({
    title: message,
    icon: 'none'
  })
}

// 请求函数
const request = (options) => {
  return new Promise((resolve, reject) => {
    // 请求拦截
    const config = requestInterceptor(options)
    
    uni.request({
      ...config,
      url: `${BASE_URL}${options.url}`,
      timeout: TIMEOUT,
      success: (response) => {
        // 响应拦截时传入原始配置
        responseInterceptor(response, config)
          .then(resolve)
          .catch(reject)
      },
      fail: (error) => {
        showError(error)
        reject(error)
      }
    })
  })
}

// 导出请求方法
export const http = {
  get: (url, data) => {
    return request({
      url,
      method: 'GET',
      data
    })
  },
  
  post: (url, data) => {
    return request({
      url,
      method: 'POST', 
      data
    })
  },
  
  put: (url, data) => {
    return request({
      url,
      method: 'PUT',
      data  
    })
  },
  
  delete: (url, data) => {
    return request({
      url,
      method: 'DELETE',
      data
    })
  }
} 